home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume18 / notation / part03 < prev    next >
Encoding:
Internet Message Format  |  1991-04-13  |  33.9 KB
  1. From: hthomas@irisa.fr (Henry Thomas)
  2. Newsgroups: comp.sources.misc
  3. Subject: v18i014:  notation - Chess text converter, Part03/03
  4. Message-ID: <1991Apr12.032957.3667@sparky.IMD.Sterling.COM>
  5. Date: 12 Apr 91 03:29:57 GMT
  6. Approved: kent@sparky.imd.sterling.com
  7. X-Checksum-Snefru: ff5d41b2 1de730ab 399df4a7 de19c66e
  8.  
  9. Submitted-by: Henry Thomas <hthomas@irisa.fr>
  10. Posting-number: Volume 18, Issue 14
  11. Archive-name: notation/part03
  12.  
  13. #! /bin/sh
  14. # This is a shell archive.  Remove anything before this line, then unpack
  15. # it by saving it into a file and typing "sh file".  To overwrite existing
  16. # files, type "sh file -c".  You can also feed this as standard input via
  17. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  18. # will see the following message at the end:
  19. #        "End of archive 3 (of 3)."
  20. # Contents:  notation.c
  21. # Wrapped by hthomas@illico on Thu Apr 11 14:44:55 1991
  22. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  23. if test -f 'notation.c' -a "${1}" != "-c" ; then 
  24.   echo shar: Will not clobber existing file \"'notation.c'\"
  25. else
  26. echo shar: Extracting \"'notation.c'\" \(31006 characters\)
  27. sed "s/^X//" >'notation.c' <<'END_OF_FILE'
  28. X/* Programme d'analyse de notation echiquienne
  29. X   Copyright (C) 1990 Henry Thomas
  30. X   Nom: notation.c
  31. X   Auteur: Henry Thomas
  32. X   Date: 27/11/90
  33. X   */
  34. X/* @(#)notation.c    2.1 4/11/91 (C) Henry Thomas */
  35. X/*
  36. XThis file is part of NOTATION program.
  37. X
  38. XNOTATION is free software; you can redistribute it and/or modify
  39. Xit under the terms of the GNU General Public License as published by
  40. Xthe Free Software Foundation; either version 1, or (at your option)
  41. Xany later version.
  42. X
  43. XNOTATION is distributed in the hope that it will be useful,
  44. Xbut WITHOUT ANY WARRANTY; without even the implied warranty of
  45. XMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  46. XGNU General Public License for more details.
  47. X
  48. XYou should have received a copy of the GNU General Public License
  49. Xalong with NOTATION; see the file COPYING.  If not, write to
  50. Xthe Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  51. X
  52. X/* --------------------- data part ---------------------- */
  53. X
  54. X/* les tableaux suivants sont les tables de transcription de notation
  55. X   selon les langages
  56. X   */
  57. X#include <stdio.h>
  58. X#include <string.h>
  59. X#include <ctype.h>
  60. X
  61. X#include "chesstype.h"
  62. X#include "drivers.h"
  63. X#include "notation.h"
  64. X#include "lexer.h"
  65. X
  66. Xextern void close_files();
  67. X
  68. X
  69. Xchar * version_string =
  70. X  "@(#)notation.c    2.1 (C) Henry Thomas\tVersion 2.1\tDated 4/11/91";
  71. X
  72. Xstatic char * keywords[]= {
  73. X  "@startplay" , "@clearboard" , "@showboard" ,
  74. X  "@whitesmove", "@blacksmove", "@configwhite", "@configblack" ,
  75. X  "@default" , "@special", "@null"
  76. X  };
  77. X
  78. Xint configuring = FALSE ;
  79. Xint configside = 0 ;
  80. X
  81. X
  82. Xstatic char * t_language[] = {
  83. X  "french", "english", "italian", "spanish", "german", "dutch" };
  84. X
  85. Xstatic int in_language = DEFAULT_INPUT_LANGUAGE ;
  86. Xstatic int out_language = DEFAULT_OUTPUT_LANGUAGE ;
  87. X
  88. Xstatic char c_french[]  = { '@' ,'R' , 'D' , 'T' , 'F' , 'C' , 'P' } ;
  89. Xstatic char c_english[] = { '@' ,'K' , 'Q' , 'R' , 'B' , 'N' , 'P' } ;
  90. Xstatic char c_italian[] = { '@' ,'R' , 'D' , 'T' , 'A' , 'C' , 'P' } ;
  91. Xstatic char c_spanish[] = { '@' ,'R' , 'D' , 'T' , 'A' , 'C' , 'P' } ;
  92. Xstatic char c_german[]  = { '@' ,'K' , 'D' , 'T' , 'L' , 'S' , 'B' } ;
  93. Xstatic char c_dutch[]   = { '@' ,'K' , 'D' , 'T' , 'L' , 'P' , 'O' } ;
  94. Xstatic char c_russian[] = { '@' ,'K' , 'F' , 'D' , 'C' , 'K' , 'P' } ;
  95. X
  96. X
  97. X/* translation tables */
  98. Xchar *in_table;
  99. X 
  100. X
  101. Xchar *  c_roque[] = { "O-O" , "O-O-O" , "o-o" , "o-o-o" , "0-0" , "0-0-0" };
  102. X
  103. X/* various notations for en passant */
  104. X#define N_EP 2
  105. Xchar * c_en_passant[] = { "ep" , "e.p." } ;
  106. X
  107. X
  108. X/* notation for catch */
  109. Xchar c_prise ='x';
  110. X
  111. X/* various comments */
  112. Xchar * c_comments[] = { "+" , "++" , 
  113. X              "?" , "??", "!", "!!", "!?", "?!",
  114. X              "mate", "draw" };
  115. X
  116. X/* movement tables */
  117. X/* move only */
  118. X/* white pawn, move */
  119. X#define NB_M_PAWN_MOVE_WD 2
  120. Xstatic int m_pawn_move_wd [][2] = {
  121. X  { 1, 0}, {2, 0}
  122. X};
  123. X
  124. X/* black pawn, move */
  125. X#define NB_M_PAWN_MOVE_BD 2
  126. Xstatic int m_pawn_move_bd [][2] = {
  127. X  {-1, 0}, {-2, 0}
  128. X};
  129. X
  130. X/* TRICK = we have added the catching move at the end of
  131. X   the non catching ones; so in check_depl, we try first 
  132. X   the non catching one and then the catching one.
  133. X   So, even if catching (x) is non indicated in the input, 
  134. X   we succeed in guessing the move
  135. X   */
  136. X/* white pawn, move */
  137. X/*#define NB_M_PAWN_WD 2*/
  138. X#define NB_M_PAWN_WD 4
  139. Xstatic int m_pawn_wd [][2] = {
  140. X  { 1, 0}, {2, 0},
  141. X/* catch... */
  142. X  { 1, 1}, { 1,-1}
  143. X};
  144. X
  145. X/* white pawn, catch */
  146. X#define NB_M_PAWN_WX 2
  147. Xstatic int m_pawn_wx [][2] = {
  148. X  { 1, 1}, { 1,-1}
  149. X};
  150. X
  151. X/* black pawn, move */
  152. X/*#define NB_M_PAWN_BD 2*/
  153. X#define NB_M_PAWN_BD 4
  154. Xstatic int m_pawn_bd [][2] = {
  155. X  {-1, 0}, {-2, 0},
  156. X/* catch... */
  157. X  {-1, 1}, {-1,-1} 
  158. X};
  159. X
  160. X/* black pawn, catch */
  161. X#define NB_M_PAWN_BX 2
  162. Xstatic int m_pawn_bx [][2] = {
  163. X  {-1, 1}, {-1,-1} 
  164. X};
  165. X
  166. X
  167. X#define NB_M_KNIGHT  8
  168. Xstatic int m_knight[][2] = { 
  169. X  { 2, 1}, { 2,-1}, {-2, 1}, {-2,-1},
  170. X  { 1, 2}, { 1,-2}, {-1, 2}, {-1,-2}
  171. X};
  172. X
  173. X#define NB_M_BISHOP 28
  174. Xstatic int m_bishop[][2] = {
  175. X  { 7, 7},  {6, 6}, { 5, 5}, { 4, 4}, { 3, 3}, { 2, 2}, { 1, 1},
  176. X  { 7,-7}, { 6,-6}, { 5,-5}, { 4,-4}, { 3,-3}, { 2,-2}, { 1,-1},
  177. X  {-7,-7}, {-6,-6}, {-5,-5}, {-4,-4}, {-3,-3}, {-2,-2}, {-1,-1},
  178. X  {-7, 7}, {-6, 6}, {-5, 5}, {-4, 4}, {-3, 3}, {-2, 2}, {-1, 1}
  179. X};
  180. X
  181. X#define NB_M_ROOK 28
  182. Xstatic int m_rook[][2] = {
  183. X  { 7, 0}, { 6, 0}, { 5, 0}, { 4, 0}, { 3, 0}, { 2, 0}, { 1, 0},
  184. X  {-7, 0}, {-6, 0}, {-5, 0}, {-4, 0}, {-3, 0}, {-2, 0}, {-1, 0},
  185. X  { 0, 7}, { 0, 6}, { 0, 5}, { 0, 4}, { 0, 3}, { 0, 2}, { 0, 1},
  186. X  { 0,-7}, { 0,-6}, { 0,-5}, { 0,-4}, { 0,-3}, { 0,-2}, { 0,-1}
  187. X};
  188. X
  189. X#define NB_M_QUEEN 56
  190. Xstatic int m_queen[][2] = {
  191. X  { 7, 7},  {6, 6}, { 5, 5}, { 4, 4}, { 3, 3}, { 2, 2}, { 1, 1},
  192. X  { 7,-7}, { 6,-6}, { 5,-5}, { 4,-4}, { 3,-3}, { 2,-2}, { 1,-1},
  193. X  {-7,-7}, {-6,-6}, {-5,-5}, {-4,-4}, {-3,-3}, {-2,-2}, {-1,-1},
  194. X  {-7, 7}, {-6, 6}, {-5, 5}, {-4, 4}, {-3, 3}, {-2, 2}, {-1, 1},
  195. X  { 7, 0}, { 6, 0}, { 5, 0}, { 4, 0}, { 3, 0}, { 2, 0}, { 1, 0},
  196. X  {-7, 0}, {-6, 0}, {-5, 0}, {-4, 0}, {-3, 0}, {-2, 0}, {-1, 0},
  197. X  { 0, 7}, { 0, 6}, { 0, 5}, { 0, 4}, { 0, 3}, { 0, 2}, { 0, 1},
  198. X  { 0,-7}, { 0,-6}, { 0,-5}, { 0,-4}, { 0,-3}, { 0,-2}, { 0,-1}
  199. X};
  200. X
  201. X#define NB_M_KING 8
  202. Xstatic int m_king[][2] = {
  203. X  { 1, 1}, { 1, 0}, { 1,-1},
  204. X  {-1, 1}, {-1, 0}, {-1,-1},
  205. X  { 0, 1}, { 0, -1}
  206. X};
  207. X
  208. X
  209. X/* I/O */
  210. XFILE * infile ;
  211. XFILE * fhelp;
  212. X
  213. Xstatic char * t_output[] = 
  214. X{ "ascii", "postscript", "tex", "roff", "xchess", "gnu" };
  215. X
  216. X
  217. X/* ---------- automata definitions --------- */
  218. X/* table for syntaxic analysis of move */
  219. X
  220. X#define FINAL    10
  221. X#define TML     FINAL   /* terminal state */
  222. X#define NBETAT     11
  223. X#define NBCLAS     8
  224. X
  225. X/* successor of state */
  226. Xstatic int transit[NBETAT][NBCLAS] = { 
  227. X/*   P a-h 1-8   -   x   =  \0   ? */ 
  228. X/*(  0   1   2   3   4   5   6   7)*/
  229. X  {  1,  2, -1, -1, -1, -1, -1, -1 }, /* etat  0 */
  230. X  { -1,  2, -1, -1,  4, -1, -1, -1 }, /* etat  1 */
  231. X  { -1,  6,  3,  4,  4,  8,TML,TML }, /* etat  2 */
  232. X  { -1,  6, -1,  4,  4,  8,TML,TML }, /* etat  3 */
  233. X  {  5,  6, -1, -1, -1, -1, -1, -1 }, /* etat  4 */
  234. X  { -1,  6, -1, -1, -1, -1, -1, -1 }, /* etat  5 */
  235. X  { -1, -1,  7, -1, -1, -1, -1, -1 }, /* etat  6 */
  236. X  { -1, -1, -1, -1, -1,  8,TML,TML }, /* etat  7 */
  237. X  {  9, -1, -1, -1, -1, -1, -1, -1 }, /* etat  8 */
  238. X  { -1, -1, -1, -1, -1, -1,TML,TML }, /* etat  9 */
  239. X  { -1, -1, -1, -1, -1, -1, -1, -1 }  /* etat 10 == terminal */
  240. X};
  241. X
  242. X/* actions to do */
  243. Xstatic int action[NBETAT][NBCLAS] = {
  244. X/*   P a-h 1-8   -   x   =  \0   ? */ 
  245. X  {  1,  2, -1, -1, -1, -1, -1, -1 }, /* etat  0 */
  246. X  { -1,  2, -1, -1, 10, -1, -1, -1 }, /* etat  1 */
  247. X  { -1, 13,  3,  4,  5, 14,  6,  7 }, /* etat  2 */
  248. X  { -1, 13, -1,  4,  5, 14,  6,  7 }, /* etat  3 */
  249. X  {  1,  2, -1, -1, -1, -1, -1, -1 }, /* etat  4 */
  250. X  { -1,  2, -1, -1, -1, -1, -1, -1 }, /* etat  5 */
  251. X  { -1, -1,  3, -1, -1, -1, -1, -1 }, /* etat  6 */
  252. X  { -1, -1, -1, -1, -1, 14,  8,  9 }, /* etat  7 */
  253. X  { 15, -1, -1, -1, -1, -1, -1, -1 }, /* etat  8 */
  254. X  { -1, -1, -1, -1, -1, -1, 17, 17 }, /* etat  9 */
  255. X  { -1, -1, -1, -1, -1, -1, -1, -1 }  /* etat 10 */
  256. X};
  257. X
  258. X
  259. X
  260. X/* current game
  261. X   the name "tos" means "top of stack"
  262. X   */
  263. Xstatic game * tos = GULL ;
  264. X
  265. X/* array to see the king is in check
  266. X   use in checkroque()
  267. X   */
  268. X
  269. X
  270. X/* booleen d'erreur */
  271. Xint error_flag = FALSE;
  272. X
  273. X
  274. X/* move to display board */
  275. Xstatic int count = 0 ;
  276. X
  277. X
  278. Xstatic int move_to_display[NB_MOVE_TO_DISP] ;
  279. Xstatic int nb_move_to_dsp = 0;
  280. Xstatic int stop_at_display = FALSE;
  281. X
  282. X/* variable holding current move */
  283. Xstatic depl * m = MULL ;
  284. X
  285. X/* current move, used by the parser */
  286. Xstatic int curpiece,  curcol,  curlig ;
  287. Xstatic int curdigit, curmove;
  288. X
  289. Xstatic format * dr;
  290. X
  291. Xstatic int driver; /* driver type, ie gnu, ascii ... */
  292. X
  293. X#define setboard(A,I,J,P,C) ({(A)->board[(I)][(J)] = (P) ; \
  294. X                 (A)->color[(I)][(J)] = (C);})
  295. X#define clsboard(A,I,J,P,C) ({(A)->board[(I)][(J)] = VOID ; \
  296. X                (A)->color[(I)][(J)] = VOID; }))
  297. X
  298. X/* --------------------------- code part --------------------- */
  299. X
  300. X
  301. Xstatic int ispiece(c)
  302. X     char c;
  303. X{
  304. X  register int i;
  305. X  
  306. X  for ( i = 0 ; (i < NUMPIECES) && (c != in_table[i]) ; i++ ) ;
  307. X  /*(void) fprintf(stdout, "piece %d %c\n" , i , c);*/
  308. X  return(i<NUMPIECES);
  309. X}
  310. X
  311. X
  312. Xstatic int piece(c)
  313. X     char c ;
  314. X{
  315. X  register int i;
  316. X  
  317. X  for ( i = 0 ; (i < NUMPIECES) && (c != in_table[i]) ; i++ ) ;
  318. X  if ( i== NUMPIECES)
  319. X    i = PAWN ;
  320. X  return(i);
  321. X}
  322. X
  323. X/* this function return yhe # entry of a keyword in a given table.
  324. X   if key is not present, it returns the default value
  325. X   */
  326. Xstatic int find_keyword(tab, nbentry,defaut,key)
  327. X     char * tab[];
  328. X     int nbentry;
  329. X     int defaut;
  330. X     char *key;
  331. X{
  332. X  int i ;
  333. X
  334. X  for(i=0; (i< nbentry) ;i++)
  335. X    if (strcmp(tab[i],key)==0)
  336. X      return(i);
  337. X
  338. X  /* we failed to find the keyword */
  339. X  (void) fprintf (stderr, "unknow keyword %s in this context\n",key);
  340. X  return(defaut);
  341. X}
  342. X
  343. X/* ---------- board management function ------------- */
  344. X
  345. Xvoid clear_board(g)
  346. X     game *g;
  347. X{
  348. X  register int i,j;
  349. X
  350. X  for (i=0; i < 10; i++ )
  351. X    for (j=0 ; j< 10 ; j++) {
  352. X      g->board[i][j] = VOID;
  353. X      g->color[i][j] = VOID;
  354. X    }
  355. X}
  356. X
  357. Xgame * new_board()
  358. X{
  359. X  game * tmp;
  360. X  int i; 
  361. X
  362. X  tmp = (game *) malloc (sizeof(game));
  363. X  ALLOCP(tmp);
  364. X  /*for (i=0; i < ((sizeof (game))/ sizeof (int)) ; i++)
  365. X    ((int *) tmp)[i] = 0;*/
  366. X  return(tmp);
  367. X}
  368. X
  369. Xvoid init_board(tgm)
  370. X  game * tgm;
  371. X{
  372. X  register int i,j;
  373. X
  374. X  clear_board(tgm);
  375. X
  376. X  for (i=1; i< 9 ; i=i+7) {
  377. X    tgm->board[i][1]= tgm->board[i][8] = ROOK ;
  378. X    tgm->board[i][2]= tgm->board[i][7] = KNIGHT ;
  379. X    tgm->board[i][3]= tgm->board[i][6] = BISHOP ;
  380. X    tgm->board[i][4]= QUEEN;
  381. X    tgm->board[i][5]= KING;
  382. X  }
  383. X  for (i=2; i< 8 ; i=i+5) 
  384. X    for (j=1; j <=8 ; j++)
  385. X      tgm->board[i][j] = PAWN;
  386. X
  387. X  for (i=1; i <=2; i++)
  388. X    for (j=1; j <=8 ; j++) {
  389. X      tgm->color[i][j] = WHITE;
  390. X      tgm->color[i+6][j] = BLACK ;
  391. X    }
  392. X}
  393. X
  394. Xdepl * new_move()
  395. X{
  396. X  depl * tmp;
  397. X  int i; 
  398. X
  399. X  tmp = (depl *) malloc (sizeof(depl));
  400. X  ALLOCP(tmp);
  401. X  /*for (i=0; i < ((sizeof (depl))/ sizeof (int)) ; i++)
  402. X    ((int *) tmp)[i] = 0;*/
  403. X  return(tmp);
  404. X}
  405. X
  406. X
  407. Xvoid init_move(m)
  408. X     depl *m;
  409. X{
  410. X  m->move= 1 ;
  411. X  m->whiteturn = TRUE ;
  412. X}
  413. X     
  414. X/* ----------- semantic evaluation of move ----------- */
  415. X/* check if  position lies within the board
  416. X   */
  417. Xint in_board(l,c)
  418. X     int l,c;
  419. X{
  420. X  return ((c >= 1) && (c <= 8) && (l >= 1) && (l <= 8));
  421. X}
  422. X
  423. X/* check that the path from pos1 to pos2 is free
  424. X   */
  425. Xint path_free(l1, c1, l2, c2)
  426. Xint l1,c1, l2, c2;
  427. X{
  428. X  int li = 1 ;
  429. X  int ci = 1 ;
  430. X  int lig, col;
  431. X
  432. X
  433. X  li = SIGN(l2-l1);
  434. X  ci = SIGN(c2-c1);
  435. X
  436. X
  437. X  if ( c1 == c2 ) {    
  438. X    col = c1;
  439. X    for (lig = l1 +li; lig != l2 ; lig +=li)
  440. X      if (tos->board[lig][col] != VOID)
  441. X    return (FALSE);
  442. X    return(TRUE);
  443. X  }
  444. X
  445. X  if ( l1 == l2) {
  446. X    lig = l1 ;
  447. X    for (col = c1 + ci; col != c2 ; col +=ci)
  448. X      if (tos->board[lig][col] != VOID)
  449. X    return (FALSE);
  450. X    return(TRUE);
  451. X  }
  452. X
  453. X  for (lig = l1+li,col =c1+ci; (lig!=l2) && (col!=c2); lig+=li, col+= ci)
  454. X    if (tos->board[lig][col] != VOID) {
  455. X      return (FALSE);
  456. X    }
  457. X  return(TRUE);
  458. X}
  459. X
  460. X/* check roque is possible */
  461. Xint check_roque()
  462. X{
  463. X  int lig, col ;
  464. X
  465. X  if (m->whiteturn)
  466. X    lig = 1 ;
  467. X  else
  468. X    lig =8;
  469. X  if (m->type == GRANDROQUE)
  470. X    for (col = 2; col < 5 ; col++)
  471. X      if (tos->board[lig][col] != VOID)
  472. X    return(FALSE);
  473. X  if (m->type == PETITROQUE)
  474. X    for (col = 6; col < 7 ; col++)
  475. X      if (tos->board[lig][col] != VOID)
  476. X    return(FALSE);
  477. X  if (m->is_check[CURCOLOR(m)])
  478. X    return(FALSE);
  479. X  return(TRUE);
  480. X}
  481. X  
  482. X/* check -- or guess -- where a given piece come */
  483. Xint guess_piece() {return(tos->board[m->fromlig][m->fromcol]); }
  484. X
  485. X/* try to guess the move -- low-level function */
  486. Xint guess_depl(nb, tab, pl1, pc1, l2,c2,path)
  487. X     int nb;
  488. X     int tab[][2];
  489. X     int *pl1, *pc1;
  490. X     int l2,c2;
  491. X     int path;
  492. X{
  493. X  int i;
  494. X  int c,l;
  495. X
  496. X  for (i=0; i< nb; i++ ) {
  497. X    l = l2 - tab[i][0];
  498. X    c = c2 - tab[i][1];
  499. X    if (in_board(l,c))
  500. X      if ((tos->board[l][c] == m->piece) &&
  501. X      (tos->color[l][c] == CURCOLOR(m)) &&
  502. X      ( !path || (path && path_free(l,c, l2, c2))) &&
  503. X      ( ((*pl1) == 0) || ((*pl1) == l) ) &&
  504. X      ( ((*pc1) == 0) || ((*pc1) == c) ) )
  505. X      {
  506. X    *pl1 = l;
  507. X    *pc1 = c;
  508. X    return(TRUE);
  509. X      }
  510. X  }
  511. X  return(FALSE);
  512. X}
  513. X
  514. X/* check for ambiguitey in a move
  515. X   used in ouptut function: the piece had beenm already moved and
  516. X   if we guess another move, there is an ambiguity
  517. X   */
  518. Xint ambiguity(frompiece, l2, c2)
  519. X     int frompiece, l2, c2 ;
  520. X{
  521. X  int l1 = 0 ;
  522. X  int c1 = 0 ;
  523. X
  524. X  switch(frompiece) {
  525. X  case PAWN:
  526. X    if (m->type == PRISE) {
  527. X      if (m->whiteturn)
  528. X    return(guess_depl(NB_M_PAWN_WX, m_pawn_wx, &l1,&c1, l2,c2, FALSE));
  529. X      else
  530. X    return(guess_depl(NB_M_PAWN_BX, m_pawn_bx, &l1,&c1, l2,c2, FALSE));
  531. X   } else {
  532. X      if (m->whiteturn)
  533. X    return(guess_depl(NB_M_PAWN_MOVE_WD, m_pawn_move_wd, 
  534. X              &l1,&c1, l2,c2, FALSE));
  535. X      else
  536. X    return(guess_depl(NB_M_PAWN_MOVE_BD, m_pawn_move_bd, 
  537. X              &l1,&c1, l2,c2, FALSE));
  538. X    }
  539. X    /* break; */
  540. X  case KNIGHT:
  541. X    return(guess_depl(NB_M_KNIGHT, m_knight, &l1,&c1, l2,c2, FALSE));
  542. X    /* break; */
  543. X  case BISHOP:
  544. X    return(guess_depl(NB_M_BISHOP, m_bishop, &l1,&c1, l2,c2, TRUE));
  545. X    /* break; */
  546. X  case ROOK:
  547. X    return(guess_depl(NB_M_ROOK, m_rook, &l1,&c1, l2,c2, TRUE));
  548. X    /* break; */
  549. X  case QUEEN:
  550. X    return(guess_depl(NB_M_QUEEN, m_queen, &l1,&c1, l2,c2, TRUE));
  551. X    /* break; */
  552. X  case KING:
  553. X    return(guess_depl(NB_M_KING, m_king, &l1,&c1, l2,c2, TRUE));
  554. X    /* break; */
  555. X  default:
  556. X    break;
  557. X  }
  558. X  return(TRUE);
  559. X}
  560. X
  561. Xint check_move(m)
  562. X     depl * m;
  563. X{
  564. X  int l1,c1,l2,c2,l;
  565. X  int tmp; /* tmp boolean */
  566. X 
  567. X  l1 = m->fromlig;
  568. X  c1 = m->fromcol;
  569. X  l2 = m->tolig;
  570. X  c2 = m->tocol;
  571. X
  572. X  if ((m->type == GRANDROQUE) || (m->type == PETITROQUE))
  573. X    return(check_roque());
  574. X
  575. X  if ((tos->board[l1][c1] != m->piece)||
  576. X      (tos->color[l1][c1] != CURCOLOR(m))){
  577. X    printf("==%d\n",tos->board[l1][c1]);
  578. X    error ((stderr,"from position and piece not correct\n"));
  579. X    return(FALSE);
  580. X  }
  581. X
  582. X  /* if prise === FALSE, we must not take a piece */
  583. X  if (tos->board[l2][c2] != VOID 
  584. X      && (m->type != PRISE) && (m->type != PROM_ET_PRISE)) {
  585. X    (void) fprintf(stderr,"catching not indicated at move %d\n",m->move);
  586. X    return(FALSE);
  587. X  }
  588. X
  589. X  /* prendre une de ses propres pieces */
  590. X  if (tos->color[l2][c2] == tos->color[l1][c1] && m->prise) {
  591. X    (void) fprintf(stderr,"attempt to catch same color piece at move %d\n",
  592. X           m->move);
  593. X    return(FALSE);
  594. X  }
  595. X
  596. X  /* we check if the move is a possible one for the piece
  597. X     */
  598. X
  599. X  switch(m->piece) {
  600. X  case PAWN:
  601. X    if (m->prise) {
  602. X      if (m->whiteturn)
  603. X    tmp = guess_depl(NB_M_PAWN_WX, m_pawn_wx, &l1,&c1, l2,c2, FALSE);
  604. X      else
  605. X    tmp = guess_depl(NB_M_PAWN_BX, m_pawn_bx, &l1,&c1, l2,c2, FALSE);
  606. X   } else {
  607. X      if (m->whiteturn)
  608. X    tmp = guess_depl(NB_M_PAWN_WD, m_pawn_wd, &l1,&c1, l2,c2, FALSE);
  609. X      else
  610. X    tmp = guess_depl(NB_M_PAWN_BD, m_pawn_bd, &l1,&c1, l2,c2, FALSE);
  611. X    }
  612. X    /* is it a "prise en passant " */
  613. X    if ((c1 != c2) && (tos->board[l2][c2] == VOID)
  614. X    && (tos->board[l1][c2] == PAWN)) {
  615. X      m->type = EN_PASSANT ;
  616. X      l = l1 + (l2 - l1)/2;
  617. X      /* we must perform here the "en passant" test */
  618. X      tos->board[l1][c2] = VOID ;
  619. X      tos->color[l1][c2] = VOID ;
  620. X      tmp = TRUE;
  621. X    }
  622. X    return(tmp);
  623. X    /* break; */
  624. X  case KNIGHT:
  625. X    return(guess_depl(NB_M_KNIGHT, m_knight, &l1,&c1, l2,c2, FALSE));
  626. X    /* break; */
  627. X  case BISHOP:
  628. X    return(guess_depl(NB_M_BISHOP, m_bishop, &l1,&c1, l2,c2, TRUE));
  629. X    /* break; */
  630. X  case ROOK:
  631. X    return(guess_depl(NB_M_ROOK, m_rook, &l1,&c1, l2,c2, TRUE));
  632. X    /* break; */
  633. X  case QUEEN:
  634. X    return(guess_depl(NB_M_QUEEN, m_queen, &l1,&c1, l2,c2, TRUE));
  635. X    /* break; */
  636. X  case KING:
  637. X    return(guess_depl(NB_M_KING, m_king, &l1,&c1, l2,c2, TRUE));
  638. X    /* break; */
  639. X  default:
  640. X    break;
  641. X  }
  642. X
  643. X  return(TRUE);
  644. X}
  645. X
  646. X/* try to guess the move -- used for shortened notation
  647. X   */
  648. Xint guess_move()
  649. X{
  650. X  int l1,c1,l2,c2;
  651. X
  652. X  if ((m->type == GRANDROQUE) || (m->type == PETITROQUE))
  653. X    return(TRUE);
  654. X
  655. X  l1 = m->fromlig ;
  656. X  c1 = m->fromcol ;
  657. X  l2 = m->tolig;
  658. X  c2 = m->tocol;
  659. X
  660. X  switch(m->piece) {
  661. X  case PAWN:
  662. X    if (m->prise) {
  663. X      if (m->whiteturn)
  664. X    (void) guess_depl(NB_M_PAWN_WX, m_pawn_wx, &l1,&c1, l2,c2, FALSE);
  665. X      else
  666. X    (void) guess_depl(NB_M_PAWN_BX, m_pawn_bx, &l1,&c1, l2,c2, FALSE);
  667. X    } else {
  668. X      if (m->whiteturn)
  669. X    (void) guess_depl(NB_M_PAWN_WD, m_pawn_wd, &l1,&c1, l2,c2, FALSE); 
  670. X      else
  671. X    (void) guess_depl(NB_M_PAWN_BD, m_pawn_bd, &l1,&c1, l2,c2, FALSE); 
  672. X    }
  673. X    break;
  674. X  case KNIGHT:
  675. X    (void) guess_depl(NB_M_KNIGHT, m_knight, &l1,&c1, l2,c2, FALSE);
  676. X    break;
  677. X  case BISHOP:
  678. X    (void) guess_depl(NB_M_BISHOP, m_bishop, &l1,&c1, l2,c2, TRUE);
  679. X    break;
  680. X  case ROOK:
  681. X    (void) guess_depl(NB_M_ROOK, m_rook, &l1,&c1, l2,c2, TRUE);
  682. X    break;
  683. X  case QUEEN:
  684. X    (void) guess_depl(NB_M_QUEEN, m_queen, &l1,&c1, l2,c2, TRUE);
  685. X    break;
  686. X  case KING:
  687. X    (void) guess_depl(NB_M_KING, m_king, &l1,&c1, l2,c2, TRUE);
  688. X    break;
  689. X  default:
  690. X    break;
  691. X  }
  692. X
  693. X  if ((l1 == 0) || (c1 == 0)) {
  694. X    if (m->whiteturn)
  695. X      error((stderr,"unable to guess move %d white (%d)\n",
  696. X         m->move,m->piece));
  697. X    else
  698. X      error((stderr,"unable to guess move %d black (%d)\n",
  699. X         m->move,m->piece));
  700. X    return(FALSE);
  701. X  } else {
  702. X    m->fromcol = c1;
  703. X    m->fromlig = l1;
  704. X    return(TRUE);
  705. X  }
  706. X}
  707. X
  708. X/* --------------- execution of move ----------------- */
  709. X
  710. X/* clear a position */
  711. Xint clear_pos(lig,col)
  712. X     int lig;
  713. X     int col;
  714. X{
  715. X  tos->board[lig][col] = VOID ;
  716. X  tos->color[lig][col] = VOID ;
  717. X  return(TRUE);
  718. X}
  719. X
  720. X/* configure the board */
  721. Xint configure()
  722. X{
  723. X  if (configuring) {
  724. X    if (m->piece == VOID)
  725. X      m->piece = PAWN ;
  726. X    tos->board[m->tolig][m->tocol] = m->piece ;
  727. X    tos->color[m->tolig][m->tocol] = configside ;
  728. X  }
  729. X  return(TRUE);
  730. X}
  731. X
  732. X/* execute a move, no checking */
  733. Xint execute_move()
  734. X{
  735. X  register int i;
  736. X
  737. X  if (m->piece == VOID )
  738. X    m->piece = PAWN;
  739. X
  740. X  if ((m->fromlig == 0) || (m->fromcol == 0))
  741. X    (void) guess_move();
  742. X  
  743. X  /* supply to the -- maybe -- deficiency of input notation
  744. X     */
  745. X  if ((m->fromlig !=0) || (m->fromcol != 0))
  746. X    m->piece = tos->board[m->fromlig][m->fromcol];
  747. X
  748. X  if (tos->board[m->tolig][m->tocol] != VOID) {
  749. X    m->type = PRISE;
  750. X    m->prise = tos->board[m->tolig][m->tocol] ;
  751. X  }
  752. X
  753. X  if (!check_move(m)) {
  754. X    if (m->whiteturn)
  755. X      error((stderr,"white move %d illegal\n",m->move));
  756. X    else
  757. X      error((stderr,"black move %d illegal\n",m->move));
  758. X  }
  759. X
  760. X  if (m->type == PETITROQUE) {
  761. X    if (m->whiteturn)
  762. X      curlig = 1 ;
  763. X    else
  764. X      curlig = 8 ;
  765. X    tos->board[curlig][7] = KING;
  766. X    tos->board[curlig][6] = ROOK;
  767. X    tos->color[curlig][7] = tos->color[curlig][5] ;
  768. X    tos->color[curlig][6] = tos->color[curlig][5] ;
  769. X    (void) clear_pos(curlig, 5);
  770. X    (void) clear_pos(curlig, 8);
  771. X  }
  772. X  if (m->type == GRANDROQUE) {
  773. X    if (m->whiteturn)
  774. X      curlig = 1 ;
  775. X    else
  776. X      curlig = 8 ;
  777. X    tos->board[curlig][3] = KING;
  778. X    tos->board[curlig][4] = ROOK;
  779. X    tos->color[curlig][3] = tos->color[curlig][5] ;
  780. X    tos->color[curlig][4] = tos->color[curlig][5] ;
  781. X    (void) clear_pos(curlig, 5);
  782. X    (void) clear_pos(curlig, 1);
  783. X  }
  784. X
  785. X        
  786. X  if (!(m->type == GRANDROQUE) || (m->type == PETITROQUE)) {
  787. X    if (m->piece == VOID)
  788. X      m->piece = tos->board[m->fromlig][m->fromcol];
  789. X    /*if (m->topiece == VOID)
  790. X      m->topiece = tos->board[m->fromlig][m->fromcol];*/
  791. X    tos->board[m->tolig][m->tocol] = tos->board[m->fromlig][m->fromcol];
  792. X    tos->color[m->tolig][m->tocol] = tos->color[m->fromlig][m->fromcol];
  793. X    (void) clear_pos(m->fromlig,m->fromcol);
  794. X  }
  795. X  
  796. X  if ((m->type == PROMOTION) || (m->type == PROM_ET_PRISE))
  797. X    tos->board[m->tolig][m->tocol] = m->promotion ;
  798. X     
  799. X  output_move(dr,m);
  800. X
  801. X  if (error_flag) {
  802. X    (void) fprintf(dr->outfile, "\nlast position encountered:\n");
  803. X    output_board(dr,tos);
  804. X    close_files();
  805. X    exit(0);
  806. X  }
  807. X
  808. X  /* do we need to display the move ? */
  809. X  if (nb_move_to_dsp > 0) {
  810. X    for (i=0; i < nb_move_to_dsp; i++)
  811. X      if (m->move == (move_to_display[i] ) && !m->whiteturn ) {
  812. X    output_board(dr,tos);
  813. X    if (stop_at_display) {
  814. X      output_end(dr);
  815. X      close_files();
  816. X      exit(0);
  817. X    }
  818. X      }
  819. X  }
  820. X
  821. X  return(TRUE);
  822. X}
  823. X
  824. X/* ------------------ automata ----------------------- */
  825. X
  826. X/* categorise the input for the automata */
  827. Xint typechar(c)
  828. X     char c;
  829. X{
  830. X  if (ispiece(c))
  831. X    return(0);
  832. X  if ((c >=  'a') && ( c <= 'h'))
  833. X    return(1);
  834. X  if ((c >=  '1') && ( c <= '8'))
  835. X    return(2);
  836. X  if ( c== '-' )
  837. X    return(3);
  838. X  if ((c == 'x') || (c == 'X' ))
  839. X    return(4);
  840. X  if (c == '=' )
  841. X    return(5);
  842. X  if (c == '\0' )
  843. X    return(6);
  844. X  return(7);
  845. X}
  846. X
  847. X
  848. X/* execute the actions decided by the automata */
  849. Xint execute(num,c)
  850. X     int num;
  851. X     char c;
  852. X{
  853. X  switch (num) {
  854. X  case 1: /* set cur piece */
  855. X    curpiece = piece(c);
  856. X    break;
  857. X  case 2: /* set cur col */
  858. X    curcol = lettertocol(c);
  859. X    break;
  860. X  case 3: /* set cur lig */
  861. X    curlig = lettertolig(c);
  862. X    break;
  863. X  case 4: /* from = cur ; prise = false */
  864. X    m->piece = curpiece ;
  865. X    m->fromcol = curcol ;
  866. X    m->fromlig = curlig;
  867. X    /*m->topiece = curpiece;*/
  868. X    break;
  869. X  case 5: /* from = cur ; prise = true */
  870. X    m->piece = curpiece ;
  871. X    m->fromcol = curcol ;
  872. X    m->fromlig = curlig;
  873. X    m->type = PRISE ;
  874. X    m->prise = curpiece;
  875. X    break;
  876. X  case 6: /* to = cur ; guess from */
  877. X  case 7: /* to = cur ; guess from ; parse remaining token */
  878. X    m->piece = curpiece ;
  879. X    m->tocol = curcol;
  880. X    m->tolig = curlig ;
  881. X
  882. X    /*m->topiece = curpiece ; /* ? */
  883. X
  884. X    if (configuring)
  885. X      (void) configure();
  886. X    else {
  887. X      (void) execute_move();
  888. X      m->whiteturn = !m->whiteturn ; 
  889. X      if (m->whiteturn) m->move++ ;
  890. X    }
  891. X    break;
  892. X  case 8: /* to = cur */
  893. X  case 9: /* to = cur */
  894. X    m->tocol = curcol;
  895. X    m->tolig = curlig ;
  896. X    /*m->topiece = curpiece ;*/
  897. X
  898. X    if (configuring)
  899. X      (void) configure();
  900. X    else {
  901. X      (void) execute_move();
  902. X      m->whiteturn = !m->whiteturn ; 
  903. X      if (m->whiteturn) m->move++ ;
  904. X    }
  905. X    break;
  906. X  case 10: /* piece = cur piece ; prise = true */
  907. X    /* later : guess from position */
  908. X    m->piece = curpiece ;
  909. X    m->type = PRISE ;
  910. X    break;
  911. X  case 11: /* grand roque */
  912. X  case 12: /* petit roque */
  913. X
  914. X    (void) execute_move();
  915. X
  916. X    m->whiteturn = !m->whiteturn ; 
  917. X    if (m->whiteturn) m->move++ ;
  918. X    break;
  919. X  case 13: /* case of simpliest algebraic notation ;
  920. X          only e2e4 : this is the transition from e2 to e4
  921. X          also the case of move such as Nge2
  922. X          from =cur; prise = FALSE;
  923. X          also:
  924. X          curcol = ...
  925. X          */
  926. X    m->piece = curpiece ;
  927. X    m->fromcol = curcol ;
  928. X    m->fromlig = curlig;
  929. X    /*m->topiece = curpiece;*/
  930. X    m->type = MOVE;
  931. X    curcol = lettertocol(c);
  932. X  case 14: /* promotion, the "=" */
  933. X    break;
  934. X  case 15: /* promotion, the piece name */
  935. X    /* to = cur ; guess from */
  936. X  case 16: 
  937. X    /* to = cur */
  938. X
  939. X    m->tocol = curcol;
  940. X    m->tolig = curlig ;
  941. X    /*m->topiece = curpiece ;*/
  942. X
  943. X    if (m->type == PRISE )
  944. X      m->type = PROM_ET_PRISE ;
  945. X    else
  946. X      m->type = PROMOTION ;
  947. X    m->promotion = curpiece = piece(c) ;
  948. X
  949. X    break;
  950. X  case 17: /* execute move for promotion */
  951. X    (void) execute_move();
  952. X
  953. X    m->whiteturn = !m->whiteturn ; 
  954. X    if (m->whiteturn) m->move++ ;
  955. X    break;
  956. X  case -1:
  957. X    break;
  958. X  default:
  959. X    break;
  960. X  }
  961. X  return(TRUE);
  962. X}
  963. X
  964. Xint parse_number(token)
  965. X     char *token;
  966. X{
  967. X  int curmove = 0 ;
  968. X  int i;
  969. X
  970. X  /* check coherency with internal numbering */
  971. X  i = 0;
  972. X  while (isdigit(token[i])) {
  973. X   curmove = curmove * 10 +  ((int) token[i++] - (int) '0' );
  974. X  }
  975. X  if (curmove != m->move)
  976. X    (void) fprintf(stderr,"problem in move numbering: %d vs %d\n",
  977. X           m->move, curmove);
  978. X  return(TRUE);
  979. X}
  980. X
  981. Xint parse_keyword(token)
  982. X     char *token;
  983. X{
  984. X  char c;
  985. X
  986. X  switch (find_keyword(keywords, NBKEYWORD, KNULL, token)) {
  987. X  case START:
  988. X    configuring = FALSE;
  989. X    m->move = 1;
  990. X    m->whiteturn = TRUE;
  991. X    break;
  992. X  case CLEAR:
  993. X    clear_board(tos);
  994. X    break;
  995. X  case SHOWBOARD:
  996. X    output_board(dr,tos);
  997. X    break;
  998. X  case TOWHITE:
  999. X    m->move = 1;
  1000. X    m->whiteturn = TRUE;
  1001. X    break;
  1002. X  case TOBLACK:
  1003. X    m->move = 1;
  1004. X    m->whiteturn = FALSE;
  1005. X    break;
  1006. X  case CONFIGWH:
  1007. X    configuring = TRUE ;
  1008. X    configside = WHITE;
  1009. X    break;
  1010. X  case CONFIGBL:
  1011. X    configuring = TRUE ;
  1012. X    configside = BLACK;
  1013. X    break;
  1014. X  case DEFAULTP:
  1015. X    init_board(tos);
  1016. X    break;
  1017. X  case SPECIAL: /* all input, up to \n is copied to output */
  1018. X    while ((( c = getc(infile)) != EOF) && (c != '\n'))
  1019. X      (void) putc (c,dr->outfile);
  1020. X    putc ('\n', dr->outfile);
  1021. X    break;
  1022. X  case KNULL:
  1023. X  default:
  1024. X    break;
  1025. X  }
  1026. X  return(TRUE);
  1027. X}
  1028. X
  1029. Xint parse_roque(token)
  1030. X     char * token;
  1031. X{ 
  1032. X  int i;
  1033. X
  1034. X  for (i=0; i < NBROQUE && (strcmp(c_roque[i],token)!=0); i++) ;
  1035. X  if ( i < NBROQUE ) {
  1036. X    if (strlen(token) == 3) {
  1037. X      m->type = PETITROQUE ;
  1038. X      (void) execute(12,DUMMYCHAR);
  1039. X    } else {
  1040. X      m->type = GRANDROQUE ;
  1041. X      (void) execute(11,DUMMYCHAR);
  1042. X    }
  1043. X    /*(void) fprintf(stderr,"ROQUE\n");*/
  1044. X    return(TRUE);
  1045. X  }
  1046. X
  1047. X  return(FALSE);
  1048. X}
  1049. X
  1050. Xint  parse_move(token)
  1051. X     char *token;
  1052. X{
  1053. X  register int i;
  1054. X  int correcte = FALSE ;
  1055. X  int erreursyntaxe = FALSE ;
  1056. X  int etat =0;
  1057. X  int code;
  1058. X  
  1059. X  i=0;
  1060. X  while ( !correcte && !erreursyntaxe ) {
  1061. X    code = typechar(token[i]);
  1062. X    (void) execute(action[etat][code],token[i]);
  1063. X    etat = transit[etat][code] ;
  1064. X    if (etat == -1) 
  1065. X      erreursyntaxe = TRUE;
  1066. X    if (etat == FINAL)
  1067. X      correcte = TRUE ;
  1068. X    i++;
  1069. X  }
  1070. X  if (erreursyntaxe) {
  1071. X    (void) fprintf(stderr, "no comprende, senor: %s\n",token);
  1072. X    return(FALSE);
  1073. X  }
  1074. X  if (correcte) {
  1075. X    /*(void) fprintf(stderr, "ia panimaiou, davai\n");*/
  1076. X  }
  1077. X  return(TRUE);
  1078. X}
  1079. X
  1080. Xvoid init_parse(m)
  1081. X     depl * m ;
  1082. X{
  1083. X  int i;
  1084. X
  1085. X  /* global position and piece variable initialised to 0
  1086. X     */
  1087. X  /* move and whiteturn unchanged */ 
  1088. X
  1089. X  m->type = MOVE ;
  1090. X
  1091. X  curpiece = m->piece = VOID ;
  1092. X  curcol = m->tocol = m->fromcol = 0;
  1093. X  curlig = m->tolig = m->fromlig = 0;
  1094. X
  1095. X  m->promotion = VOID;
  1096. X  m->prise = VOID;
  1097. X
  1098. X  for (i=0; i< 3; i++)
  1099. X    m->is_check[i] = FALSE ;
  1100. X  curdigit = curmove = 0;
  1101. X}
  1102. X
  1103. X/* ------------------- top routines -------------------- */
  1104. X
  1105. X/* cette fonction analyse les arguments de la ligne de commande
  1106. X   */
  1107. Xint parse_options(argc,argv)
  1108. X     int argc;
  1109. X     char * argv[];
  1110. X{
  1111. X  int narg =1 ;
  1112. X  int i;
  1113. X  register int c;
  1114. X  char cp[132];
  1115. X  char chaine[MAXTOKLEN];
  1116. X
  1117. X  infile = stdin;
  1118. X  dr->outfile = stdout;
  1119. X  nb_move_to_dsp = 0;
  1120. X
  1121. X  while (narg < argc ) {
  1122. X    (void) strcpy (cp,argv[narg]);
  1123. X    switch (cp[0]) {
  1124. X    case '-' :
  1125. X      switch (cp[1]) {
  1126. X      case 'f' : /* from langage */
  1127. X    if  ((narg+1) >= argc )
  1128. X      fatal((stderr,"missing argument to %s option",cp));
  1129. X    narg++ ;
  1130. X    in_language = find_keyword (t_language, NBLANGUAGE,
  1131. X                    DEFAULT_INPUT_LANGUAGE,
  1132. X                    argv[narg]);
  1133. X    break;
  1134. X      case 't' : /* to langage */
  1135. X    if  ((narg+1) >= argc )
  1136. X      fatal((stderr,"missing argument to %s option",cp));
  1137. X    narg++ ;
  1138. X    out_language = find_keyword (t_language, NBLANGUAGE,
  1139. X                     DEFAULT_OUTPUT_LANGUAGE,
  1140. X                     argv[narg]);
  1141. X    break;
  1142. X      case 'o' : /* next arg is output file */
  1143. X    narg++ ;
  1144. X    if ((dr->outfile = fopen (argv[narg],"w+")) == NULL) {
  1145. X      (void) fprintf (stderr,"can't open %s output file\n",argv[narg]);
  1146. X      (void) fprintf (stderr,"assume stdout for output\n");
  1147. X    }
  1148. X    break;
  1149. X      case 'e':
  1150. X    if  ((narg+1) >= argc )
  1151. X      fatal((stderr,"missing argument to %s option",cp));
  1152. X    narg++ ;
  1153. X
  1154. X    i=0;
  1155. X    nb_move_to_dsp = 0;
  1156. X    move_to_display[nb_move_to_dsp] = 0;
  1157. X    while (isdigit(argv[narg][i])) {
  1158. X      move_to_display[nb_move_to_dsp] =
  1159. X        ((int) argv[narg][i] - (int) '0')
  1160. X          + move_to_display[nb_move_to_dsp] * 10;
  1161. X      i++;
  1162. X    }
  1163. X    nb_move_to_dsp++;
  1164. X    stop_at_display = TRUE;
  1165. X    break;
  1166. X      case 'c':
  1167. X    if  ((narg+1) >= argc )
  1168. X      fatal((stderr,"missing argument to %s option",cp));
  1169. X    narg++ ;
  1170. X
  1171. X    i=0;
  1172. X    while (isdigit(argv[narg][i])) {
  1173. X      move_to_display[nb_move_to_dsp] = 0;
  1174. X      while (isdigit(argv[narg][i])) {
  1175. X        move_to_display[nb_move_to_dsp] =
  1176. X          ((int) argv[narg][i] - (int) '0')
  1177. X          + move_to_display[nb_move_to_dsp] * 10;
  1178. X        i++;
  1179. X      }
  1180. X      nb_move_to_dsp++;
  1181. X
  1182. X      if (nb_move_to_dsp > NB_MOVE_TO_DISP)
  1183. X        fatal((stderr,"max. number of move to display exceeded"));
  1184. X
  1185. X      /* process next number */
  1186. X      if (argv[narg][i] == ',')
  1187. X        i++;
  1188. X    }
  1189. X    break;
  1190. X      case 'a': /* algebraic output */
  1191. X    dr->output_move_format = ALGEBRAIC;
  1192. X    break;
  1193. X      case 's':  /* shortened output */
  1194. X    dr->output_move_format = SHORTENED;
  1195. X    break;
  1196. X      case 'b': /* display only the board, no move */
  1197. X    dr->only_board = TRUE;
  1198. X    break;
  1199. X      case 'd': /* output driver */
  1200. X    if  ((narg+1) >= argc )
  1201. X      fatal((stderr,"missing argument to %s option",cp));
  1202. X    narg++ ;
  1203. X    driver = find_keyword(t_output, NB_DRIVER, DEFAULT_DRIVER,
  1204. X                  argv[narg]);
  1205. X    break;
  1206. X      case 'h': /* help file */
  1207. X    (void) strcpy(chaine,LIB_DIR);
  1208. X        if ((fhelp = fopen(strcat(chaine,HELP_FILE),"r")) == NULL)
  1209. X          fatal((stderr,"Can't find help file.\n"));
  1210. X        else {
  1211. X          while ((c = getc(fhelp)) != EOF)
  1212. X            (void) fputc(c,stderr);
  1213. X          (void) fclose(fhelp);
  1214. X      exit(0);
  1215. X        }
  1216. X         break;
  1217. X      default:
  1218. X    error((stderr,"unknown command line options %s\n",cp));
  1219. X    break;
  1220. X      }
  1221. X      break;
  1222. X    default: /* assume this is the input file */
  1223. X      if ((infile = fopen (cp,"r")) == NULL)
  1224. X    fatal((stderr,"can't open %s input file\n",cp));
  1225. X    }
  1226. X    narg++;
  1227. X  } /* process next arg */
  1228. X  return(argc);
  1229. X}
  1230. X
  1231. Xvoid close_files()
  1232. X{
  1233. X  if (infile != stdin )
  1234. X    (void) fclose(infile);
  1235. X  if (dr->outfile != stdout )
  1236. X    (void) fclose(dr->outfile);
  1237. X}
  1238. X
  1239. Xint associe_traduction (table, langage)
  1240. Xchar ** table;
  1241. Xint langage ;
  1242. X{
  1243. X  switch (langage) {
  1244. X  case FRENCH :
  1245. X    *table = c_french ;
  1246. X    break;
  1247. X  case ENGLISH:
  1248. X    *table = c_english ;
  1249. X    break;
  1250. X  case ITALIAN:
  1251. X    *table = c_italian ;
  1252. X    break;
  1253. X  case SPANISH:
  1254. X    *table = c_spanish ;
  1255. X    break;
  1256. X  case GERMAN:
  1257. X    *table = c_german ;
  1258. X    break;
  1259. X  case DUTCH:
  1260. X    *table = c_dutch ;
  1261. X    break;
  1262. X  case RUSSIAN:
  1263. X    (void) fprintf(stderr,"russian not yet implemented\n");
  1264. X    *table = c_russian ;
  1265. X    break;
  1266. X  default:
  1267. X    error((stderr,"unknown langage\n"));
  1268. X  }
  1269. X  return(langage);
  1270. X}
  1271. X
  1272. X/* ------------- main --------------------- */
  1273. X
  1274. Xmain(argc,argv)
  1275. X     int argc;
  1276. X     char * argv[];
  1277. X{
  1278. X  (void) fprintf(stderr,"%s\n",version_string);
  1279. X  
  1280. X  /* allocation of driver descriptor */
  1281. X  dr = new_driver();
  1282. X
  1283. X  /* default configuration */
  1284. X  init_driver(dr,DEFAULT_DRIVER);
  1285. X  (void) associe_traduction(&in_table,  DEFAULT_INPUT_LANGUAGE );
  1286. X  (void) associe_traduction(&(dr->out_table), DEFAULT_OUTPUT_LANGUAGE);
  1287. X
  1288. X  (void) parse_options(argc,argv);
  1289. X
  1290. X  (void) associe_traduction (&in_table, in_language);
  1291. X  (void) associe_traduction (&(dr->out_table), out_language);
  1292. X
  1293. X  /* assoc driver */
  1294. X  init_driver(dr,driver);
  1295. X
  1296. X  configuring = FALSE;
  1297. X  configside = VOID;
  1298. X
  1299. X  /* initialise output file */
  1300. X  output_init(dr);
  1301. X
  1302. X  if (error_flag)
  1303. X    fatal((stderr,"too many errors"));
  1304. X
  1305. X  /* allocation of move descriptor */
  1306. X  m = new_move();
  1307. X  init_move(m);
  1308. X  
  1309. X  /* allocation of board descriptor */
  1310. X  tos = new_board();
  1311. X  init_board(tos);
  1312. X
  1313. X  /*output_board(dr,tos);*/
  1314. X
  1315. X  while (nexttoken()) {
  1316. X    /*(void) fprintf(stdout,"%s%\n", curtok);*/
  1317. X    init_parse(m);
  1318. X    (void) parsetoken();
  1319. X  }
  1320. X  if ((count == 0) && !error_flag)
  1321. X    output_board(dr,tos);
  1322. X
  1323. X  if (error_flag) {
  1324. X    error((stderr,"last valid position:\n"));
  1325. X    output_board(dr,tos);
  1326. X    fatal((stderr,"too many errors"));
  1327. X  }
  1328. X
  1329. X  /* terminates output files */
  1330. X  output_end(dr);
  1331. X
  1332. X  /* close files */
  1333. X  close_files();
  1334. X
  1335. X  /* exit properly */
  1336. X#ifdef TURBOC
  1337. X  return(TRUE);
  1338. X#else
  1339. X  exit(0);
  1340. X#endif
  1341. X}
  1342. END_OF_FILE
  1343. if test 31006 -ne `wc -c <'notation.c'`; then
  1344.     echo shar: \"'notation.c'\" unpacked with wrong size!
  1345. fi
  1346. # end of 'notation.c'
  1347. fi
  1348. echo shar: End of archive 3 \(of 3\).
  1349. cp /dev/null ark3isdone
  1350. MISSING=""
  1351. for I in 1 2 3 ; do
  1352.     if test ! -f ark${I}isdone ; then
  1353.     MISSING="${MISSING} ${I}"
  1354.     fi
  1355. done
  1356. if test "${MISSING}" = "" ; then
  1357.     echo You have unpacked all 3 archives.
  1358.     rm -f ark[1-9]isdone
  1359. else
  1360.     echo You still need to unpack the following archives:
  1361.     echo "        " ${MISSING}
  1362. fi
  1363. ##  End of shell archive.
  1364. exit 0
  1365.  
  1366. --
  1367. Henry Thomas - IRISA          - E-mail: Henry.Thomas@irisa.fr 
  1368. Campus Universitaire de Beaulieu - Phone: (+33)99 36 20 00 +549  
  1369. 35042 RENNES CEDEX FRANCE      - Fax: (+33)99 38 38 32 Telex: UNIRISA 950473F
  1370. Telex Atlas X400: /X121=842950473/@atlas.fr, Fax:/X121=200099383832/@atlas.fr
  1371. --
  1372. ... Words, and the words of men, flicker and flutter and beat
  1373. Warning, sorrow and gain, salutations and mirth...        R. Kipling
  1374.  
  1375. exit 0 # Just in case...
  1376. -- 
  1377. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1378. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1379. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1380. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1381.